+2006-06-21 Matthias Clasen <mclasen@redhat.com>
+
+ Apply a patch by John Palmieri to use buffered io using
+ GIOChannels, clean up error handling and support Cups 1.2
+ api in the printing code.
+
+ * acconfig.h:
+ * configure.in: Detect Cups 1.2
+
+ * gtk/gtkdebug.h:
+ * gtk/gtkmain.c: Add a printing debug key.
+
+ * gtk/gtkprintbackend.[hc]: Remove the GError parameter from
+ gtk_print_backend_print_stream, and take a GIOChannel instead
+ of an fd.
+
+ * gtk/gtkprinter-private.h:
+ * gtk/gtkprinter.c: Replace the fd parameter of
+ _gtk_printer_create_cairo_surface by a GIOChannel.
+
+ * gtk/gtkprintjob.[hc]: Remove the GError parameter from
+ gtk_print_job_send and make it return void.
+
+ * gtk/gtkprintoperation-unix.c:
+ * gtk/gtkprintjob.c: Adjust callers, add some debugging support.
+
+ * modules/printbackends/Makefile.am: Fix DIST_SUBDIRS.
+
+ * modules/printbackends/cups/Makefile.am:
+ * modules/printbackends/lpr/Makefile.am: Add debug CFLAGS.
+
+ * modules/printbackends/cups/gtkcupsutils.[hc]:
+ * modules/printbackends/cups/gtkprintbackendcups.c:
+ * modules/printbackends/file/gtkprintbackendfile.c:
+ * modules/printbackends/lpr/gtkprintbackendfile.c: Adapt to
+ the GIOChannel and GError changes, add debug output
+
2006-06-21 Matthias Clasen <mclasen@redhat.com>
* gtk/gtkprinter.c (gtk_enumerate_printers): Remove an
+2006-06-21 Matthias Clasen <mclasen@redhat.com>
+
+ Apply a patch by John Palmieri to use buffered io using
+ GIOChannels, clean up error handling and support Cups 1.2
+ api in the printing code.
+
+ * acconfig.h:
+ * configure.in: Detect Cups 1.2
+
+ * gtk/gtkdebug.h:
+ * gtk/gtkmain.c: Add a printing debug key.
+
+ * gtk/gtkprintbackend.[hc]: Remove the GError parameter from
+ gtk_print_backend_print_stream, and take a GIOChannel instead
+ of an fd.
+
+ * gtk/gtkprinter-private.h:
+ * gtk/gtkprinter.c: Replace the fd parameter of
+ _gtk_printer_create_cairo_surface by a GIOChannel.
+
+ * gtk/gtkprintjob.[hc]: Remove the GError parameter from
+ gtk_print_job_send and make it return void.
+
+ * gtk/gtkprintoperation-unix.c:
+ * gtk/gtkprintjob.c: Adjust callers, add some debugging support.
+
+ * modules/printbackends/Makefile.am: Fix DIST_SUBDIRS.
+
+ * modules/printbackends/cups/Makefile.am:
+ * modules/printbackends/lpr/Makefile.am: Add debug CFLAGS.
+
+ * modules/printbackends/cups/gtkcupsutils.[hc]:
+ * modules/printbackends/cups/gtkprintbackendcups.c:
+ * modules/printbackends/file/gtkprintbackendfile.c:
+ * modules/printbackends/lpr/gtkprintbackendfile.c: Adapt to
+ the GIOChannel and GError changes, add debug output
+
2006-06-21 Matthias Clasen <mclasen@redhat.com>
* gtk/gtkprinter.c (gtk_enumerate_printers): Remove an
#undef GETTEXT_PACKAGE
+#undef HAVE_CUPS_API_1_2
+
/* #undef PACKAGE */
/* #undef VERSION */
CUPS_CFLAGS=`cups-config --cflags | sed 's/-O[0-9]*//' | sed 's/-m[^\t]*//g'`
CUPS_LIBS=`cups-config --libs`
+ CUPS_API_VERSION=`cups-config --api-version`
+ CUPS_API_MAJOR=`echo -n $CUPS_API_VERSION | awk -F. '{print $1}'`
+ CUPS_API_MINOR=`echo -n $CUPS_API_VERSION | awk -F. '{print $2}'`
+
+ if test $CUPS_API_MAJOR -gt 1 -o \
+ $CUPS_API_MAJOR -eq 1 -a $CUPS_API_MINOR -ge 2; then
+ AC_DEFINE(HAVE_CUPS_API_1_2)
+ fi
+
+ AC_SUBST(CUPS_API_MAJOR)
+ AC_SUBST(CUPS_API_MINOR)
AC_SUBST(CUPS_CFLAGS)
AC_SUBST(CUPS_LIBS)
fi
GTK_DEBUG_MULTIHEAD = 1 << 6,
GTK_DEBUG_MODULES = 1 << 7,
GTK_DEBUG_GEOMETRY = 1 << 8,
- GTK_DEBUG_ICONTHEME = 1 << 9
+ GTK_DEBUG_ICONTHEME = 1 << 9,
+ GTK_DEBUG_PRINTING = 1 << 10
} GtkDebugFlag;
#ifdef G_ENABLE_DEBUG
{"multihead", GTK_DEBUG_MULTIHEAD},
{"modules", GTK_DEBUG_MODULES},
{"geometry", GTK_DEBUG_GEOMETRY},
- {"icontheme", GTK_DEBUG_ICONTHEME}
+ {"icontheme", GTK_DEBUG_ICONTHEME},
+ {"printing", GTK_DEBUG_PRINTING}
};
#endif /* G_ENABLE_DEBUG */
void
gtk_print_backend_print_stream (GtkPrintBackend *backend,
GtkPrintJob *job,
- gint data_fd,
+ GIOChannel *data_io,
GtkPrintJobCompleteFunc callback,
gpointer user_data,
- GDestroyNotify dnotify,
- GError **error)
+ GDestroyNotify dnotify)
{
g_return_if_fail (GTK_IS_PRINT_BACKEND (backend));
GTK_PRINT_BACKEND_GET_CLASS (backend)->print_stream (backend,
job,
- data_fd,
+ data_io,
callback,
user_data,
- dnotify,
- error);
+ dnotify);
}
void
void (*request_printer_list) (GtkPrintBackend *backend);
void (*print_stream) (GtkPrintBackend *backend,
GtkPrintJob *job,
- gint data_fd,
+ GIOChannel *data_io,
GtkPrintJobCompleteFunc callback,
gpointer user_data,
- GDestroyNotify dnotify,
- GError **error);
+ GDestroyNotify dnotify);
/* Printer methods: */
void (*printer_request_details) (GtkPrinter *printer);
GtkPrintSettings *settings,
gdouble height,
gdouble width,
- gint cache_fd);
+ GIOChannel *cache_io);
GtkPrinterOptionSet * (*printer_get_options) (GtkPrinter *printer,
GtkPrintSettings *settings,
GtkPageSetup *page_setup,
const gchar *printer_name);
void gtk_print_backend_print_stream (GtkPrintBackend *print_backend,
GtkPrintJob *job,
- gint data_fd,
+ GIOChannel *data_io,
GtkPrintJobCompleteFunc callback,
gpointer user_data,
- GDestroyNotify dnotify,
- GError **error);
+ GDestroyNotify dnotify);
GList * gtk_print_backend_load_modules (void);
void gtk_print_backend_destroy (GtkPrintBackend *print_backend);
GtkPrintSettings *settings,
gdouble width,
gdouble height,
- gint cache_fd);
+ GIOChannel *cache_io);
GList * _gtk_printer_list_papers (GtkPrinter *printer);
void _gtk_printer_get_hard_margins (GtkPrinter *printer,
gdouble *top,
GtkPrintSettings *settings,
gdouble width,
gdouble height,
- gint cache_fd)
+ GIOChannel *cache_io)
{
GtkPrintBackendClass *backend_class = GTK_PRINT_BACKEND_GET_CLASS (printer->priv->backend);
return backend_class->printer_create_cairo_surface (printer, settings,
- width, height, cache_fd);
+ width, height, cache_io);
}
GList *
{
gchar *title;
- gint spool_file_fd;
+ GIOChannel *spool_io;
cairo_surface_t *surface;
GtkPrintStatus status;
priv = job->priv = GTK_PRINT_JOB_GET_PRIVATE (job);
- priv->spool_file_fd = -1;
+ priv->spool_io = NULL;
priv->title = g_strdup ("");
priv->surface = NULL;
GtkPrintJob *job = GTK_PRINT_JOB (object);
GtkPrintJobPrivate *priv = job->priv;
- if (priv->spool_file_fd >= 0)
+ if (priv->spool_io != NULL)
{
- close (priv->spool_file_fd);
- priv->spool_file_fd = -1;
+ g_io_channel_unref (priv->spool_io);
+ priv->spool_io = NULL;
}
if (priv->backend)
GError **error)
{
GtkPrintJobPrivate *priv;
+ GError *tmp_error;
+
+ tmp_error = NULL;
g_return_val_if_fail (GTK_IS_PRINT_JOB (job), FALSE);
priv = job->priv;
- priv->spool_file_fd = g_open (filename, O_RDONLY|O_BINARY);
- if (priv->spool_file_fd < 0)
- {
- gchar *display_filename = g_filename_display_name (filename);
- int save_errno = errno;
-
- g_set_error (error,
- G_FILE_ERROR,
- g_file_error_from_errno (save_errno),
- _("Failed to open file '%s': %s"),
- display_filename,
- g_strerror (save_errno));
-
- g_free (display_filename);
+ priv->spool_io = g_io_channel_new_file (filename, "r", &tmp_error);
+
+ if (tmp_error == NULL)
+ g_io_channel_set_encoding (priv->spool_io, NULL, &tmp_error);
+ if (tmp_error != NULL)
+ {
+ g_propagate_error (error, tmp_error);
return FALSE;
}
- return TRUE;
+
+ return TRUE;
}
/**
gchar *filename;
gdouble width, height;
GtkPaperSize *paper_size;
-
+ int fd;
+ GError *tmp_error;
+
+ tmp_error = NULL;
+
g_return_val_if_fail (GTK_IS_PRINT_JOB (job), NULL);
priv = job->priv;
if (priv->surface)
return priv->surface;
- g_return_val_if_fail (priv->spool_file_fd == -1, NULL);
+ g_return_val_if_fail (priv->spool_io == NULL, NULL);
- priv->spool_file_fd = g_file_open_tmp ("gtkprint_XXXXXX",
- &filename,
- error);
- if (priv->spool_file_fd == -1)
- return NULL;
+ fd = g_file_open_tmp ("gtkprint_XXXXXX",
+ &filename,
+ &tmp_error);
+ if (fd == -1)
+ {
+ g_propagate_error (error, tmp_error);
+ return NULL;
+ }
- fchmod (priv->spool_file_fd, S_IRUSR | S_IWUSR);
+ fchmod (fd, S_IRUSR | S_IWUSR);
+
+#ifdef G_ENABLE_DEBUG
+ /* If we are debugging printing don't delete the tmp files */
+ if (!(gtk_debug_flags & GTK_DEBUG_PRINTING))
+#endif /* G_ENABLE_DEBUG */
unlink (filename);
paper_size = gtk_page_setup_get_paper_size (priv->page_setup);
width = gtk_paper_size_get_width (paper_size, GTK_UNIT_POINTS);
height = gtk_paper_size_get_height (paper_size, GTK_UNIT_POINTS);
+
+ priv->spool_io = g_io_channel_unix_new (fd);
+ g_io_channel_set_close_on_unref (priv->spool_io, TRUE);
+ g_io_channel_set_encoding (priv->spool_io, NULL, &tmp_error);
+ if (tmp_error != NULL)
+ {
+ g_io_channel_unref (priv->spool_io);
+ priv->spool_io = NULL;
+ g_propagate_error (error, tmp_error);
+ return NULL;
+ }
+
priv->surface = _gtk_printer_create_cairo_surface (priv->printer,
priv->settings,
width, height,
- priv->spool_file_fd);
-
+ priv->spool_io);
+
return priv->surface;
}
/**
* gtk_print_job_send:
* @job: a GtkPrintJob
- * @callback: function to call when the job completes
+ * @callback: function to call when the job completes or an error occures
* @user_data: user data that gets passed to @callback
* @dnotify: destroy notify for @user_data
- * @error: return location for errors, or %NULL
*
* Sends the print job off to the printer.
*
- * Return value: %FALSE if an error occurred
- *
* Since: 2.10
**/
-gboolean
+void
gtk_print_job_send (GtkPrintJob *job,
GtkPrintJobCompleteFunc callback,
gpointer user_data,
- GDestroyNotify dnotify,
- GError **error)
+ GDestroyNotify dnotify)
{
GtkPrintJobPrivate *priv;
- GError *print_error = NULL;
- g_return_val_if_fail (GTK_IS_PRINT_JOB (job), FALSE);
+ g_return_if_fail (GTK_IS_PRINT_JOB (job));
priv = job->priv;
- g_return_val_if_fail (priv->spool_file_fd > 0, FALSE);
+ g_return_if_fail (priv->spool_io != NULL);
gtk_print_job_set_status (job, GTK_PRINT_STATUS_SENDING_DATA);
- lseek (priv->spool_file_fd, 0, SEEK_SET);
+
+ g_io_channel_seek_position (priv->spool_io, 0, G_SEEK_SET, NULL);
+
gtk_print_backend_print_stream (priv->backend, job,
- priv->spool_file_fd,
- callback, user_data, dnotify,
- &print_error);
- if (print_error)
- {
- g_propagate_error (error, print_error);
-
- return FALSE;
- }
-
- return TRUE;
+ priv->spool_io,
+ callback, user_data, dnotify);
}
GType
void gtk_print_job_set_track_print_status (GtkPrintJob *job,
gboolean track_status);
gboolean gtk_print_job_get_track_print_status (GtkPrintJob *job);
-gboolean gtk_print_job_send (GtkPrintJob *job,
+void gtk_print_job_send (GtkPrintJob *job,
GtkPrintJobCompleteFunc callback,
gpointer user_data,
- GDestroyNotify dnotify,
- GError **error);
+ GDestroyNotify dnotify);
GType gtk_print_capabilities_get_type (void) G_GNUC_CONST;
if (op_unix->job != NULL)
gtk_print_job_send (op_unix->job,
unix_finish_send,
- op_unix, NULL,
- NULL);
+ op_unix, NULL);
if (wait)
{
SUBDIRS += cups
endif
-DIST_SUBDIRS=cups pdf lpr
+DIST_SUBDIRS=cups file lpr
-I$(top_builddir)/gdk \
$(CUPS_CFLAGS) \
-DGTK_PRINT_BACKEND_ENABLE_UNSUPPORTED \
- $(GTK_DEP_CFLAGS)
+ $(GTK_DEP_CFLAGS) \
+ $(GTK_DEBUG_FLAGS)
LDADDS = \
$(GTK_DEP_LIBS) \
*/
#include "gtkcupsutils.h"
+#include "config.h"
+#include "gtkdebug.h"
#include <errno.h>
#include <unistd.h>
gtk_cups_request_new (http_t *connection,
GtkCupsRequestType req_type,
gint operation_id,
- gint data_fd,
+ GIOChannel *data_io,
const char *server,
const char *resource)
{
request->last_status = HTTP_CONTINUE;
request->attempts = 0;
- request->data_fd = data_fd;
+ request->data_io = data_io;
request->ipp_request = ippNew();
request->ipp_request->request.op.operation_id = operation_id;
gchar length[255];
struct stat data_info;
+ GTK_NOTE (PRINTING,
+ g_print ("CUPS Backend: %s\n", G_STRFUNC));
+
request->poll_state = GTK_CUPS_HTTP_WRITE;
- if (request->data_fd != 0)
+ if (request->data_io != NULL)
{
- fstat (request->data_fd, &data_info);
+ fstat (g_io_channel_unix_get_fd (request->data_io), &data_info);
sprintf (length, "%lu", (unsigned long)ippLength(request->ipp_request) + data_info.st_size);
}
else
{
ipp_state_t ipp_status;
+ GTK_NOTE (PRINTING,
+ g_print ("CUPS Backend: %s\n", G_STRFUNC));
+
request->poll_state = GTK_CUPS_HTTP_WRITE;
ipp_status = ippWrite(request->http, request->ipp_request);
if (ipp_status == IPP_DATA)
{
- if (request->data_fd != 0)
+ if (request->data_io != NULL)
request->state = GTK_CUPS_POST_WRITE_DATA;
else
{
static void
_post_write_data (GtkCupsRequest *request)
{
- ssize_t bytes;
+ gsize bytes;
char buffer[_GTK_CUPS_MAX_CHUNK_SIZE];
http_status_t http_status;
+ GTK_NOTE (PRINTING,
+ g_print ("CUPS Backend: %s\n", G_STRFUNC));
+
request->poll_state = GTK_CUPS_HTTP_WRITE;
if (httpCheck (request->http))
if (http_status == HTTP_CONTINUE || http_status == HTTP_OK)
{
+ GIOStatus io_status;
+ GError *error;
+
+ error = NULL;
+
/* send data */
- bytes = read(request->data_fd, buffer, _GTK_CUPS_MAX_CHUNK_SIZE);
+ io_status =
+ g_io_channel_read_chars (request->data_io,
+ buffer,
+ _GTK_CUPS_MAX_CHUNK_SIZE,
+ &bytes,
+ &error);
+
+ if (io_status == G_IO_STATUS_ERROR)
+ {
+ request->state = GTK_CUPS_POST_DONE;
+ request->poll_state = GTK_CUPS_HTTP_IDLE;
+
+ gtk_cups_result_set_error (request->result, "Error reading from cache file: %s", error->message);
- if (bytes == 0)
+ g_error_free (error);
+ return;
+ }
+ else if (bytes == 0 && io_status == G_IO_STATUS_EOF)
{
request->state = GTK_CUPS_POST_CHECK;
request->poll_state = GTK_CUPS_HTTP_READ;
request->attempts = 0;
return;
}
- else if (bytes == -1)
- {
- request->state = GTK_CUPS_POST_DONE;
- request->poll_state = GTK_CUPS_HTTP_IDLE;
-
- gtk_cups_result_set_error (request->result, "Error reading from cache file: %s", strerror (errno));
- return;
- }
-
- if (httpWrite(request->http, buffer, (int)bytes) < bytes)
+
+
+#if HAVE_CUPS_API_1_2
+ if (httpWrite2(request->http, buffer, bytes) < bytes)
+#else
+ if (httpWrite(request->http, buffer, (int) bytes) < bytes)
+#endif /* HAVE_CUPS_API_1_2 */
{
request->state = GTK_CUPS_POST_DONE;
request->poll_state = GTK_CUPS_HTTP_IDLE;
http_status = request->last_status;
+ GTK_NOTE (PRINTING,
+ g_print ("CUPS Backend: %s - status %i\n", G_STRFUNC, http_status));
+
request->poll_state = GTK_CUPS_HTTP_READ;
if (http_status == HTTP_CONTINUE)
{
ipp_state_t ipp_status;
+ GTK_NOTE (PRINTING,
+ g_print ("CUPS Backend: %s\n", G_STRFUNC));
+
request->poll_state = GTK_CUPS_HTTP_READ;
if (request->result->ipp_response == NULL)
static void
_get_send (GtkCupsRequest *request)
{
+ GTK_NOTE (PRINTING,
+ g_print ("CUPS Backend: %s\n", G_STRFUNC));
+
request->poll_state = GTK_CUPS_HTTP_WRITE;
- if (request->data_fd == 0)
+ if (request->data_io == NULL)
{
- gtk_cups_result_set_error (request->result, "Get requires an open file descriptor");
+ gtk_cups_result_set_error (request->result, "Get requires an open io channel");
request->state = GTK_CUPS_GET_DONE;
request->poll_state = GTK_CUPS_HTTP_IDLE;
{
http_status_t http_status;
+ GTK_NOTE (PRINTING,
+ g_print ("CUPS Backend: %s\n", G_STRFUNC));
+
http_status = request->last_status;
request->poll_state = GTK_CUPS_HTTP_READ;
_get_read_data (GtkCupsRequest *request)
{
char buffer[_GTK_CUPS_MAX_CHUNK_SIZE];
- int bytes;
-
+ gsize bytes;
+ gsize bytes_written;
+ GIOStatus io_status;
+ GError *error;
+
+ GTK_NOTE (PRINTING,
+ g_print ("CUPS Backend: %s\n", G_STRFUNC));
+
+ error = NULL;
+
request->poll_state = GTK_CUPS_HTTP_READ;
-
+
+#if HAVE_CUPS_API_1_2
+ bytes = httpRead2(request->http, buffer, sizeof(buffer));
+#else
bytes = httpRead(request->http, buffer, sizeof(buffer));
+#endif /* HAVE_CUPS_API_1_2 */
+ GTK_NOTE (PRINTING,
+ g_print ("CUPS Backend: %i bytes read\n", bytes));
+
if (bytes == 0)
{
request->state = GTK_CUPS_GET_DONE;
return;
}
-
- if (write (request->data_fd, buffer, bytes) == -1)
- {
- char *error_msg;
+
+ io_status =
+ g_io_channel_write_chars (request->data_io,
+ buffer,
+ bytes,
+ &bytes_written,
+ &error);
+ if (io_status == G_IO_STATUS_ERROR)
+ {
request->state = GTK_CUPS_POST_DONE;
request->poll_state = GTK_CUPS_HTTP_IDLE;
- error_msg = strerror (errno);
- gtk_cups_result_set_error (request->result, error_msg ? error_msg:"");
+ gtk_cups_result_set_error (request->result, error->message);
+ g_error_free (error);
}
}
gchar *server;
gchar *resource;
- gint data_fd;
+ GIOChannel *data_io;
gint attempts;
GtkCupsResult *result;
GtkCupsRequest * gtk_cups_request_new (http_t *connection,
GtkCupsRequestType req_type,
gint operation_id,
- gint data_fd,
+ GIOChannel *data_io,
const char *server,
const char *resource);
void gtk_cups_request_ipp_add_string (GtkCupsRequest *request,
#include "gtkprintercups.h"
#include "gtkcupsutils.h"
-
+#include "gtkdebug.h"
typedef struct _GtkPrintBackendCupsClass GtkPrintBackendCupsClass;
static gboolean cups_job_info_poll_timeout (gpointer user_data);
static void gtk_print_backend_cups_print_stream (GtkPrintBackend *backend,
GtkPrintJob *job,
- gint data_fd,
+ GIOChannel *data_io,
GtkPrintJobCompleteFunc callback,
gpointer user_data,
- GDestroyNotify dnotify,
- GError **error);
+ GDestroyNotify dnotify);
static cairo_surface_t * cups_printer_create_cairo_surface (GtkPrinter *printer,
GtkPrintSettings *settings,
gdouble width,
gdouble height,
- gint cache_fd);
+ GIOChannel *cache_io);
static void
G_MODULE_EXPORT void
pb_module_init (GTypeModule *module)
{
+ GTK_NOTE (PRINTING,
+ g_print ("CUPS Backend: Initializing the CUPS print backend module\n"));
+
gtk_print_backend_cups_register_type (module);
gtk_printer_cups_register_type (module);
}
GtkPrintBackend *
gtk_print_backend_cups_new (void)
{
+ GTK_NOTE (PRINTING,
+ g_print ("CUPS Backend: Creating a new CUPS print backend object\n"));
+
return g_object_new (GTK_TYPE_PRINT_BACKEND_CUPS, NULL);
}
const unsigned char *data,
unsigned int length)
{
- gint fd = GPOINTER_TO_INT (closure);
- gssize written;
-
+ GIOChannel *io = (GIOChannel *)closure;
+ gsize written;
+ GError *error;
+
+ error = NULL;
+
+ GTK_NOTE (PRINTING,
+ g_print ("CUPS Backend: Writting %i byte chunk to temp file\n", length));
+
while (length > 0)
{
- written = write (fd, data, length);
+ g_io_channel_write_chars (io, data, length, &written, &error);
- if (written == -1)
+ if (error != NULL)
{
- if (errno == EAGAIN || errno == EINTR)
- continue;
-
+ GTK_NOTE (PRINTING,
+ g_print ("CUPS Backend: Error writting to temp file, %s\n", error->message));
+
+ g_error_free (error);
return CAIRO_STATUS_WRITE_ERROR;
}
+ GTK_NOTE (PRINTING,
+ g_print ("CUPS Backend: Wrote %i bytes to temp file\n", written));
+
data += written;
length -= written;
}
GtkPrintSettings *settings,
gdouble width,
gdouble height,
- gint cache_fd)
+ GIOChannel *cache_io)
{
cairo_surface_t *surface;
/* TODO: check if it is a ps or pdf printer */
- surface = cairo_ps_surface_create_for_stream (_cairo_write_to_cups, GINT_TO_POINTER (cache_fd), width, height);
+ surface = cairo_ps_surface_create_for_stream (_cairo_write_to_cups, cache_io, width, height);
/* TODO: DPI from settings object? */
cairo_surface_set_fallback_resolution (surface, 300, 300);
static void
cups_free_print_stream_data (CupsPrintStreamData *data)
{
+ GTK_NOTE (PRINTING,
+ g_print ("CUPS Backend: %s\n", G_STRFUNC));
+
if (data->dnotify)
data->dnotify (data->user_data);
g_object_unref (data->job);
GError *error = NULL;
CupsPrintStreamData *ps = user_data;
+ GTK_NOTE (PRINTING,
+ g_print ("CUPS Backend: %s\n", G_STRFUNC));
+
if (gtk_cups_result_is_error (result))
error = g_error_new_literal (gtk_print_error_quark (),
GTK_PRINT_ERROR_INTERNAL_ERROR,
static void
gtk_print_backend_cups_print_stream (GtkPrintBackend *print_backend,
GtkPrintJob *job,
- gint data_fd,
+ GIOChannel *data_io,
GtkPrintJobCompleteFunc callback,
gpointer user_data,
- GDestroyNotify dnotify,
- GError **error)
+ GDestroyNotify dnotify)
{
GtkPrinterCups *cups_printer;
CupsPrintStreamData *ps;
GtkPrintSettings *settings;
const gchar *title;
+ GTK_NOTE (PRINTING,
+ g_print ("CUPS Backend: %s\n", G_STRFUNC));
+
cups_printer = GTK_PRINTER_CUPS (gtk_print_job_get_printer (job));
settings = gtk_print_job_get_settings (job);
request = gtk_cups_request_new (NULL,
GTK_CUPS_POST,
IPP_PRINT_JOB,
- data_fd,
+ data_io,
NULL,
cups_printer->device_uri);
gtk_print_backend_cups_finalize (GObject *object)
{
GtkPrintBackendCups *backend_cups;
+
+ GTK_NOTE (PRINTING,
+ g_print ("CUPS Backend: finalizing CUPS backend module\n"));
backend_cups = GTK_PRINT_BACKEND_CUPS (object);
{
GtkPrintBackendCups *backend_cups;
+ GTK_NOTE (PRINTING,
+ g_print ("CUPS Backend: %s\n", G_STRFUNC));
+
backend_cups = GTK_PRINT_BACKEND_CUPS (object);
if (backend_cups->list_printers_poll > 0)
GtkCupsPollState poll_state;
gboolean result;
+ GTK_NOTE (PRINTING,
+ g_print ("CUPS Backend: %s <source %p>\n", G_STRFUNC, source));
+
dispatch = (GtkPrintCupsDispatchWatch *) source;
poll_state = gtk_cups_request_get_poll_state (dispatch->request);
GtkPrintCupsDispatchWatch *dispatch;
dispatch = (GtkPrintCupsDispatchWatch *) source;
-
+
+ GTK_NOTE (PRINTING,
+ g_print ("CUPS Backend: %s <source %p>\n", G_STRFUNC, source));
+
*timeout_ = -1;
return gtk_cups_request_read_write (dispatch->request);
result = gtk_cups_request_get_result (dispatch->request);
+ GTK_NOTE (PRINTING,
+ g_print ("CUPS Backend: %s <source %p>\n", G_STRFUNC, source));
+
if (gtk_cups_result_is_error (result))
- g_warning (gtk_cups_result_get_error_string (result));
+ g_warning ("Error result: %s", gtk_cups_result_get_error_string (result));
ep_callback (GTK_PRINT_BACKEND (dispatch->backend), result, user_data);
{
GtkPrintCupsDispatchWatch *dispatch;
+ GTK_NOTE (PRINTING,
+ g_print ("CUPS Backend: %s <source %p>\n", G_STRFUNC, source));
+
dispatch = (GtkPrintCupsDispatchWatch *) source;
gtk_cups_request_free (dispatch->request);
dispatch = (GtkPrintCupsDispatchWatch *) g_source_new (&_cups_dispatch_watch_funcs,
sizeof (GtkPrintCupsDispatchWatch));
+ GTK_NOTE (PRINTING,
+ g_print ("CUPS Backend: %s <source %p> - Executing cups request on server '%s' and resource '%s'\n", G_STRFUNC, dispatch, request->server, request->resource));
+
dispatch->request = request;
dispatch->backend = g_object_ref (print_backend);
dispatch->data_poll = NULL;
printer = gtk_print_backend_find_printer (GTK_PRINT_BACKEND (backend),
printer_name);
+ GTK_NOTE (PRINTING,
+ g_print ("CUPS Backend: %s - Got printer info for printer '%s'\n", G_STRFUNC, printer_name));
+
if (!printer)
- return;
+ {
+ GTK_NOTE (PRINTING,
+ g_print ("CUPS Backend: Could not find printer called '%s'\n", printer_name));
+ return;
+ }
cups_printer = GTK_PRINTER_CUPS (printer);
request = gtk_cups_request_new (NULL,
GTK_CUPS_POST,
IPP_GET_PRINTER_ATTRIBUTES,
- 0,
+ NULL,
NULL,
NULL);
gtk_cups_request_ipp_add_string (request, IPP_TAG_OPERATION, IPP_TAG_URI,
"printer-uri", NULL, printer_uri);
+ GTK_NOTE (PRINTING,
+ g_print ("CUPS Backend: %s - Requesting printer info for URI '%s'\n", G_STRFUNC, printer_uri));
+
g_free (printer_uri);
gtk_cups_request_ipp_add_strings (request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
request = gtk_cups_request_new (NULL,
GTK_CUPS_POST,
IPP_GET_JOB_ATTRIBUTES,
- 0,
+ NULL,
NULL,
NULL);
request = gtk_cups_request_new (NULL,
GTK_CUPS_POST,
CUPS_GET_PRINTERS,
- 0,
+ NULL,
NULL,
NULL);
typedef struct {
GtkPrinterCups *printer;
- gint ppd_fd;
- gchar *ppd_filename;
+ GIOChannel *ppd_io;
} GetPPDData;
static void
get_ppd_data_free (GetPPDData *data)
{
- close (data->ppd_fd);
- unlink (data->ppd_filename);
- g_free (data->ppd_filename);
+ GTK_NOTE (PRINTING,
+ g_print ("CUPS Backend: %s\n", G_STRFUNC));
+
+ g_io_channel_unref (data->ppd_io);
g_object_unref (data->printer);
g_free (data);
}
ipp_t *response;
GtkPrinter *printer;
+ GTK_NOTE (PRINTING,
+ g_print ("CUPS Backend: %s\n", G_STRFUNC));
+
printer = GTK_PRINTER (data->printer);
GTK_PRINTER_CUPS (printer)->reading_ppd = FALSE;
response = gtk_cups_result_get_response (result);
- data->printer->ppd_file = ppdOpenFile (data->ppd_filename);
+ /* let ppdOpenFd take over the ownership of the open file */
+ g_io_channel_seek_position (data->ppd_io, 0, G_SEEK_SET, NULL);
+ data->printer->ppd_file = ppdOpenFd (dup (g_io_channel_unix_get_fd (data->ppd_io)));
+
gtk_printer_set_has_details (printer, TRUE);
g_signal_emit_by_name (printer, "details-acquired", printer, TRUE);
}
GtkPrintBackend *print_backend;
GtkPrinterCups *cups_printer;
GtkCupsRequest *request;
+ char *ppd_filename;
gchar *resource;
http_t *http;
GetPPDData *data;
-
+ int fd;
+
cups_printer = GTK_PRINTER_CUPS (printer);
error = NULL;
+
+ GTK_NOTE (PRINTING,
+ g_print ("CUPS Backend: %s\n", G_STRFUNC));
+
/* FIXME this can return NULL! */
http = httpConnectEncrypt (cups_printer->hostname,
cups_printer->port,
data = g_new0 (GetPPDData, 1);
- data->ppd_fd = g_file_open_tmp ("gtkprint_ppd_XXXXXX",
- &data->ppd_filename,
- &error);
+ fd = g_file_open_tmp ("gtkprint_ppd_XXXXXX",
+ &ppd_filename,
+ &error);
+
+#ifdef G_ENABLE_DEBUG
+ /* If we are debugging printing don't delete the tmp files */
+ if (!(gtk_debug_flags & GTK_DEBUG_PRINTING))
+ unlink (ppd_filename);
+#else
+ unlink (ppd_filename);
+#endif /* G_ENABLE_DEBUG */
if (error != NULL)
{
g_warning ("%s", error->message);
g_error_free (error);
httpClose (http);
+ g_free (ppd_filename);
g_free (data);
g_signal_emit_by_name (printer, "details-acquired", printer, FALSE);
return;
}
- fchmod (data->ppd_fd, S_IRUSR | S_IWUSR);
+ fchmod (fd, S_IRUSR | S_IWUSR);
+ data->ppd_io = g_io_channel_unix_new (fd);
+ g_io_channel_set_encoding (data->ppd_io, NULL, NULL);
+ g_io_channel_set_close_on_unref (data->ppd_io, TRUE);
data->printer = g_object_ref (printer);
request = gtk_cups_request_new (http,
GTK_CUPS_GET,
0,
- data->ppd_fd,
+ data->ppd_io,
cups_printer->hostname,
resource);
+ GTK_NOTE (PRINTING,
+ g_print ("CUPS Backend: Requesting resource %s to be written to temp file %s\n", resource, ppd_filename));
+
g_free (resource);
-
+ g_free (ppd_filename);
+
cups_printer->reading_ppd = TRUE;
print_backend = gtk_printer_get_backend (printer);
request = gtk_cups_request_new (NULL,
GTK_CUPS_POST,
CUPS_GET_DEFAULT,
- 0,
+ NULL,
NULL,
NULL);
{
GtkPaperSize *paper_size;
ppd_option_t *option;
-
+ ppd_coption_t *coption;
+
ppdMarkDefaults (ppd_file);
paper_size = gtk_page_setup_get_paper_size (page_setup);
GtkPageSetup *page_setup);
static void gtk_print_backend_file_print_stream (GtkPrintBackend *print_backend,
GtkPrintJob *job,
- gint data_fd,
+ GIOChannel *data_io,
GtkPrintJobCompleteFunc callback,
gpointer user_data,
- GDestroyNotify dnotify,
- GError **error);
+ GDestroyNotify dnotify);
static cairo_surface_t * file_printer_create_cairo_surface (GtkPrinter *printer,
GtkPrintSettings *settings,
gdouble width,
gdouble height,
- gint cache_fd);
+ GIOChannel *cache_io);
static void
gtk_print_backend_file_register_type (GTypeModule *module)
const unsigned char *data,
unsigned int length)
{
- gint fd = GPOINTER_TO_INT (closure);
- gssize written;
-
+ GIOChannel *io = (GIOChannel *)closure;
+ gsize written;
+ GError *error;
+
+ error = NULL;
+
+ GTK_NOTE (PRINTING,
+ g_print ("FILE Backend: Writting %i byte chunk to temp file\n", length));
+
while (length > 0)
{
- written = write (fd, data, length);
+ g_io_channel_write_chars (io, data, length, &written, &error);
- if (written == -1)
+ if (error != NULL)
{
- if (errno == EAGAIN || errno == EINTR)
- continue;
-
+ GTK_NOTE (PRINTING,
+ g_print ("FILE Backend: Error writting to temp file, %s\n", error->message));
+
+ g_error_free (error);
return CAIRO_STATUS_WRITE_ERROR;
}
+ GTK_NOTE (PRINTING,
+ g_print ("FILE Backend: Wrote %i bytes to temp file\n", written));
+
data += written;
length -= written;
}
GtkPrintSettings *settings,
gdouble width,
gdouble height,
- gint cache_fd)
+ GIOChannel *cache_io)
{
cairo_surface_t *surface;
- surface = cairo_pdf_surface_create_for_stream (_cairo_write, GINT_TO_POINTER (cache_fd), width, height);
+ surface = cairo_pdf_surface_create_for_stream (_cairo_write, cache_io, width, height);
/* TODO: DPI from settings object? */
cairo_surface_set_fallback_resolution (surface, 300, 300);
GtkPrintBackend *backend;
GtkPrintJobCompleteFunc callback;
GtkPrintJob *job;
- gint target_fd;
+ GIOChannel *target_io;
gpointer user_data;
GDestroyNotify dnotify;
} _PrintStreamData;
{
_PrintStreamData *ps = (_PrintStreamData *) user_data;
- if (ps->target_fd > 0)
- close (ps->target_fd);
+ if (ps->target_io != NULL)
+ g_io_channel_unref (ps->target_io);
if (ps->callback)
ps->callback (ps->job, ps->user_data, error);
gchar buf[_STREAM_MAX_CHUNK_SIZE];
gsize bytes_read;
GError *error;
+ GIOStatus read_status;
_PrintStreamData *ps = (_PrintStreamData *) user_data;
- gint source_fd;
error = NULL;
- source_fd = g_io_channel_unix_get_fd (source);
-
- bytes_read = read (source_fd,
- buf,
- _STREAM_MAX_CHUNK_SIZE);
+ read_status =
+ g_io_channel_read_chars (source,
+ buf,
+ _STREAM_MAX_CHUNK_SIZE,
+ &bytes_read,
+ &error);
- if (bytes_read > 0)
+ if (read_status != G_IO_STATUS_ERROR)
{
- if (write (ps->target_fd, buf, bytes_read) == -1)
- {
- error = g_error_new (GTK_PRINT_ERROR,
- GTK_PRINT_ERROR_INTERNAL_ERROR,
- g_strerror (errno));
- }
- }
- else if (bytes_read == -1)
- {
- error = g_error_new (GTK_PRINT_ERROR,
- GTK_PRINT_ERROR_INTERNAL_ERROR,
- g_strerror (errno));
+ gsize bytes_written;
+
+ g_io_channel_write_chars (ps->target_io,
+ buf,
+ bytes_read,
+ &bytes_written,
+ &error);
}
- if (bytes_read == 0 || error != NULL)
+ if (error != NULL || read_status == G_IO_STATUS_EOF)
{
file_print_cb (GTK_PRINT_BACKEND_FILE (ps->backend), error, user_data);
+ if (error != NULL)
+ {
+ GTK_NOTE (PRINTING,
+ g_print ("FILE Backend: %s\n", error->message));
+
+ g_error_free (error);
+ }
+
return FALSE;
}
+ GTK_NOTE (PRINTING,
+ g_print ("FILE Backend: Writting %i byte chunk to target file\n", bytes_read));
+
return TRUE;
}
static void
gtk_print_backend_file_print_stream (GtkPrintBackend *print_backend,
GtkPrintJob *job,
- gint data_fd,
+ GIOChannel *data_io,
GtkPrintJobCompleteFunc callback,
gpointer user_data,
- GDestroyNotify dnotify,
- GError **error)
+ GDestroyNotify dnotify)
{
GError *internal_error = NULL;
GtkPrinter *printer;
_PrintStreamData *ps;
GtkPrintSettings *settings;
- GIOChannel *save_channel;
const gchar *uri;
gchar *filename = NULL;
printer = gtk_print_job_get_printer (job);
settings = gtk_print_job_get_settings (job);
- error = NULL;
+ internal_error = NULL;
uri = gtk_print_settings_get (settings, GTK_PRINT_SETTINGS_OUTPUT_URI);
if (uri)
ps->job = g_object_ref (job);
ps->backend = print_backend;
- ps->target_fd = creat (filename, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH);
- g_free (filename);
+ ps->target_io = g_io_channel_new_file (filename, "w", &internal_error);
- if (ps->target_fd == -1)
+ if (internal_error == NULL)
+ g_io_channel_set_encoding (ps->target_io, NULL, &internal_error);
+
+ if (internal_error != NULL)
{
- internal_error = g_error_new (GTK_PRINT_ERROR,
- GTK_PRINT_ERROR_INTERNAL_ERROR,
- g_strerror (errno));
+ file_print_cb (GTK_PRINT_BACKEND_FILE (print_backend),
+ internal_error,
+ ps);
- file_print_cb (GTK_PRINT_BACKEND_FILE (print_backend),
- internal_error, ps);
- g_propagate_error (error, internal_error);
+ g_error_free (internal_error);
return;
}
-
- save_channel = g_io_channel_unix_new (data_fd);
- g_io_add_watch (save_channel,
+ g_io_add_watch (data_io,
G_IO_IN | G_IO_PRI | G_IO_ERR | G_IO_HUP,
(GIOFunc) file_write,
ps);
-I$(top_srcdir)/gdk \
-I$(top_builddir)/gdk \
-DGTK_PRINT_BACKEND_ENABLE_UNSUPPORTED \
- $(GTK_DEP_CFLAGS)
+ $(GTK_DEP_CFLAGS) \
+ $(GTK_DEBUG_FLAGS)
LDADDS = \
$(GTK_DEP_LIBS) \
#include <glib/gi18n-lib.h>
+#include "gtkdebug.h"
#include "gtkprintoperation.h"
#include "gtkprintbackendlpr.h"
#include "gtkprinter.h"
GtkPrintSettings *settings,
gdouble width,
gdouble height,
- gint cache_fd);
+ GIOChannel *cache_io);
static void gtk_print_backend_lpr_print_stream (GtkPrintBackend *print_backend,
GtkPrintJob *job,
- gint data_fd,
+ GIOChannel *data_io,
GtkPrintJobCompleteFunc callback,
gpointer user_data,
- GDestroyNotify dnotify,
- GError **error);
+ GDestroyNotify dnotify);
static void
gtk_print_backend_lpr_register_type (GTypeModule *module)
const unsigned char *data,
unsigned int length)
{
- gint fd = GPOINTER_TO_INT (closure);
- gssize written;
-
+ GIOChannel *io = (GIOChannel *)closure;
+ gsize written;
+ GError *error;
+
+ error = NULL;
+
+ GTK_NOTE (PRINTING,
+ g_print ("LPR Backend: Writting %i byte chunk to temp file\n", length));
+
while (length > 0)
{
- written = write (fd, data, length);
+ g_io_channel_write_chars (io, data, length, &written, &error);
- if (written == -1)
+ if (error != NULL)
{
- if (errno == EAGAIN || errno == EINTR)
- continue;
-
+ GTK_NOTE (PRINTING,
+ g_print ("LPR Backend: Error writting to temp file, %s\n", error->message));
+
+ g_error_free (error);
return CAIRO_STATUS_WRITE_ERROR;
}
+ GTK_NOTE (PRINTING,
+ g_print ("LPR Backend: Wrote %i bytes to temp file\n", written));
+
data += written;
length -= written;
}
return CAIRO_STATUS_SUCCESS;
}
-
static cairo_surface_t *
lpr_printer_create_cairo_surface (GtkPrinter *printer,
GtkPrintSettings *settings,
gdouble width,
gdouble height,
- gint cache_fd)
+ GIOChannel *cache_io)
{
cairo_surface_t *surface;
- surface = cairo_ps_surface_create_for_stream (_cairo_write, GINT_TO_POINTER (cache_fd), width, height);
+ surface = cairo_ps_surface_create_for_stream (_cairo_write, cache_io, width, height);
/* TODO: DPI from settings object? */
cairo_surface_set_fallback_resolution (surface, 300, 300);
gpointer user_data;
GDestroyNotify dnotify;
- gint in;
- gint out;
- gint err;
-
+ GIOChannel *in;
} _PrintStreamData;
static void
{
_PrintStreamData *ps = (_PrintStreamData *) user_data;
- if (ps->in > 0)
- close (ps->in);
-
- if (ps->out > 0)
- close (ps->out);
-
- if (ps->err > 0)
- close (ps->err);
+ if (ps->in != NULL)
+ g_io_channel_unref (ps->in);
if (ps->callback)
ps->callback (ps->job, ps->user_data, error);
gchar buf[_LPR_MAX_CHUNK_SIZE];
gsize bytes_read;
GError *error;
+ GIOStatus status;
_PrintStreamData *ps = (_PrintStreamData *) user_data;
- gint source_fd;
error = NULL;
- source_fd = g_io_channel_unix_get_fd (source);
-
- bytes_read = read (source_fd,
- buf,
- _LPR_MAX_CHUNK_SIZE);
+ status =
+ g_io_channel_read_chars (source,
+ buf,
+ _LPR_MAX_CHUNK_SIZE,
+ &bytes_read,
+ &error);
- if (bytes_read > 0)
- {
- if (write (ps->in, buf, bytes_read) == -1)
- {
- error = g_error_new (GTK_PRINT_ERROR,
- GTK_PRINT_ERROR_INTERNAL_ERROR,
- g_strerror (errno));
- }
- }
- else if (bytes_read == -1)
+ if (status != G_IO_STATUS_ERROR)
{
- error = g_error_new (GTK_PRINT_ERROR,
- GTK_PRINT_ERROR_INTERNAL_ERROR,
- g_strerror (errno));
+ gsize bytes_written;
+
+ g_io_channel_write_chars (ps->in,
+ buf,
+ bytes_read,
+ &bytes_written,
+ &error);
}
- if (bytes_read == 0 || error != NULL)
+ if (error != NULL || status == G_IO_STATUS_EOF)
{
lpr_print_cb (GTK_PRINT_BACKEND_LPR (ps->backend),
error, user_data);
if (error)
g_error_free (error);
+ if (error != NULL)
+ {
+ GTK_NOTE (PRINTING,
+ g_print ("LPR Backend: %s\n", error->message));
+
+ g_error_free (error);
+ }
+
return FALSE;
}
+ GTK_NOTE (PRINTING,
+ g_print ("LPR Backend: Writting %i byte chunk to lpr pipe\n", bytes_read));
+
+
return TRUE;
}
static void
gtk_print_backend_lpr_print_stream (GtkPrintBackend *print_backend,
GtkPrintJob *job,
- gint data_fd,
+ GIOChannel *data_io,
GtkPrintJobCompleteFunc callback,
gpointer user_data,
- GDestroyNotify dnotify,
- GError **error)
+ GDestroyNotify dnotify)
{
GError *print_error = NULL;
GtkPrinter *printer;
_PrintStreamData *ps;
GtkPrintSettings *settings;
- GIOChannel *send_channel;
gint argc;
- gchar **argv;
- const gchar *cmd_line;
-
+ gint in_fd;
+ gchar **argv = NULL;
+ const char *cmd_line;
+
printer = gtk_print_job_get_printer (job);
settings = gtk_print_job_get_settings (job);
ps->user_data = user_data;
ps->dnotify = dnotify;
ps->job = g_object_ref (job);
- ps->in = 0;
- ps->out = 0;
- ps->err = 0;
+ ps->in = NULL;
/* spawn lpr with pipes and pipe ps file to lpr */
if (!g_shell_parse_argv (cmd_line, &argc, &argv, &print_error))
- {
- lpr_print_cb (GTK_PRINT_BACKEND_LPR (print_backend),
- print_error, ps);
- g_propagate_error (error, print_error);
- return;
- }
+ goto out;
if (!g_spawn_async_with_pipes (NULL,
argv,
NULL,
NULL,
NULL,
- &ps->in,
- &ps->out,
- &ps->err,
+ &in_fd,
+ NULL,
+ NULL,
&print_error))
- {
- lpr_print_cb (GTK_PRINT_BACKEND_LPR (print_backend),
- print_error, ps);
- g_propagate_error (error, print_error);
goto out;
+ ps->in = g_io_channel_unix_new (in_fd);
+
+ g_io_channel_set_encoding (ps->in, NULL, &print_error);
+ if (print_error != NULL)
+ {
+ if (ps->in != NULL)
+ g_io_channel_unref (ps->in);
+
+ goto out;
}
- send_channel = g_io_channel_unix_new (data_fd);
-
- g_io_add_watch (send_channel,
+ g_io_add_watch (data_io,
G_IO_IN | G_IO_PRI | G_IO_ERR | G_IO_HUP,
(GIOFunc) lpr_write,
ps);
out:
- g_strfreev (argv);
+ if (argv != NULL)
+ g_strfreev (argv);
+
+ if (print_error != NULL)
+ {
+ lpr_print_cb (GTK_PRINT_BACKEND_LPR (print_backend),
+ print_error, ps);
+ g_error_free (print_error);
+ }
}
static void
projects / gtk4.git / commitdiff